home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / dev / misc / dvmake_3_8p4.lha / dmake-3.8p4 / getinp.c < prev    next >
C/C++ Source or Header  |  1992-04-07  |  15KB  |  532 lines
  1. /* RCS      -- $Header: /u/dvadura/src/generic/dmake/src/RCS/getinp.c,v 1.2 1992/04/07 04:42:46 dvadura Exp $
  2. -- SYNOPSIS -- handle reading of input.
  3. -- 
  4. -- DESCRIPTION
  5. --    The code in this file reads the input from the specified stream
  6. --    into the provided buffer of size Buffer_size.  In doing so it deletes
  7. --    comments.  Comments are delimited by the #, and
  8. --    <nl> character sequences.  An exception is \# which
  9. --    is replaced by # in the input.  Line continuations are signalled
  10. --    at the end of a line and are recognized inside comments.
  11. --    The line continuation is always  <\><nl>.
  12. --
  13. --    If the file to read is NIL(FILE) then the Get_line routine returns the
  14. --    next rule from the builtin rule table if there is one.
  15. --
  16. -- AUTHOR
  17. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  18. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  19. --
  20. -- COPYRIGHT
  21. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  22. -- 
  23. --      This program is free software; you can redistribute it and/or
  24. --      modify it under the terms of the GNU General Public License
  25. --      (version 1), as published by the Free Software Foundation, and
  26. --      found in the file 'LICENSE' included with this distribution.
  27. -- 
  28. --      This program is distributed in the hope that it will be useful,
  29. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  30. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31. --      GNU General Public License for more details.
  32. -- 
  33. --      You should have received a copy of the GNU General Public License
  34. --      along with this program;  if not, write to the Free Software
  35. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  36. --
  37. -- LOG
  38. --     $Log: getinp.c,v $
  39.  * Revision 1.2  1992/04/07  04:42:46  dvadura
  40.  * Minor clean up and a check for -X flag on the execution of #! lines.
  41.  *
  42.  * Revision 1.1  1992/01/24  03:27:56  dvadura
  43.  * dmake Version 3.8, Initial revision
  44.  *
  45. */
  46.  
  47. #include "extern.h"
  48.  
  49. #define IS_WHITE(A)  ((A == ' ') || (A == '\t') || (A == '\n') || (A == '\r'))
  50. #define SCAN_WHITE(A) \
  51.     while( IS_WHITE(*A) ) A++;
  52.  
  53. static    int    _is_conditional ANSI((char*));
  54. static    int    _handle_conditional ANSI((int, TKSTRPTR));
  55.  
  56. static int  rule_ind = 0;    /* index of rule when reading Rule_tab     */
  57. static int  skip = FALSE;    /* if true the skip input         */
  58.  
  59.  
  60. PUBLIC int
  61. Get_line( buf, fil )/*
  62. ======================
  63.         Read a line of input from the file stripping
  64.         off comments.  The routine returns TRUE if EOF */
  65. char *buf;
  66. FILE *fil;
  67. {
  68.    extern   char **Rule_tab;
  69.    register char *p;
  70.    register char *c;
  71.    char      *q;
  72.    char             *buf_org;
  73.    static   int     ignore = FALSE;
  74.    int          cont   = FALSE;
  75.    int          pos    = 0;
  76.    int         res;
  77.  
  78.    DB_ENTER( "Get_line" );
  79.  
  80.    if( fil == NIL(FILE) ) {
  81.       /* Reading the internal rule table.  Set the rule_index to zero.
  82.        * This way ReadEnvironment works as expected every time. */
  83.  
  84.       while( (p = Rule_tab[ rule_ind++ ]) != NIL(char) )
  85.      /* The last test in this if '*p != '~', handles the environment
  86.       * passing conventions used by MKS to pass arguments.  We want to
  87.       * skip those environment entries. */
  88.      if( !Readenv || (Readenv && (strchr(p,'=') != NIL(char)) && *p!='~')){
  89.         strcpy( buf, p );
  90.  
  91.         DB_PRINT( "io", ("Returning [%s]", buf) );
  92.         DB_RETURN( FALSE );
  93.      }
  94.  
  95.       rule_ind = 0;
  96.  
  97.       DB_PRINT( "io", ("Done Ruletab") );
  98.       DB_RETURN( TRUE );
  99.    }
  100.  
  101.    buf_org = buf;
  102.  
  103. do_again:
  104.    do {
  105.       p = buf+pos;
  106.       if(feof( fil ) || (fgets( p, Buffer_size-pos, fil ) == NIL(char)))
  107.      DB_RETURN( TRUE );
  108.  
  109.       Line_number++;
  110.  
  111.       /* ignore input if ignore flag set and line ends in a continuation
  112.      character. */
  113.       q = p+strlen(p)-2;
  114.       if( q<p ) q=p;
  115.  
  116.       /* ignore each RETURN at the end of a line before any further
  117.        * processing */
  118.       if( q[0] == '\r' && q[1] == '\n' ) {
  119.      q[0] = '\n';
  120.      q[1] = '\0';
  121.      q--;
  122.       }
  123.       /* you also have to deal with END_OF_FILE chars to process raw
  124.        * DOS-Files. Normally they are the last chars in file, but after
  125.        * working on these file with vi, there is an additional NEWLINE
  126.        * after the last END_OF_FILE. So if the second last char in the
  127.        * actual line is END_OF_FILE, you can skip the last char. Then
  128.        * you can search the line back until you find no more END_OF_FILE
  129.        * and nuke each you found by string termination. */
  130.       if( q[0] == '\032' )
  131.      q--;
  132.       while( q[1] == '\032' ) {
  133.      q[1] = '\0';
  134.      q--;
  135.       }
  136.  
  137.       if( ignore ) {
  138.      if( q[0] != CONTINUATION_CHAR || q[1] != '\n' )  ignore = FALSE;
  139.      *p = '\0';
  140.      continue;
  141.       }
  142.  
  143.       c = Do_comment(p, &q, Group || (*buf == '\t'));
  144.       
  145.       /* Does the end of the line end in a continuation sequence? */
  146.       
  147.       if( (q[0] == CONTINUATION_CHAR) && (q[1] == '\n')) {
  148.      /* If the continuation was at the end of a comment then ignore the
  149.       * next input line, (or lines until we get one ending in just <nl>)
  150.       * else it's a continuation, so build the input line from several
  151.       * text lines on input.  The maximum size of this is governened by
  152.       * Buffer_size */
  153.      if( q != p && q[-1] == CONTINUATION_CHAR ) {
  154.         strcpy( q, q+1 );
  155.         q--;
  156.         cont = FALSE;
  157.      }
  158.      else if( c != NIL(char) )
  159.         ignore = TRUE;
  160.      else
  161.         cont   = TRUE;
  162.       }
  163.       else {
  164.      cont = FALSE;
  165.       }
  166.  
  167.       q    = ( c == NIL(char) ) ? q+2 : c;
  168.       pos += q-p;
  169.    }
  170.    while( (cont || !*buf) && (pos <= Buffer_size) );
  171.  
  172.    if( buf[ pos-1 ] == '\n' )
  173.       buf[ --pos ] = '\0';
  174.    else
  175.       if( pos == Buffer_size-1 )
  176.      Fatal( "Input line too long, increase MAXLINELENGTH" );
  177.  
  178.  
  179.    /* Now that we have the next line of input to make, we should check to
  180.     * see if it is a conditional expression.  If it is then process it,
  181.     * otherwise pass it on to the parser. */
  182.  
  183.    if( *(p = _strspn(buf, " \t\r\n")) == CONDSTART ) {
  184.       TKSTR token;
  185.  
  186.       SET_TOKEN( &token, p );
  187.  
  188.       p = Get_token( &token, "", FALSE );
  189.  
  190.       if( (res = _is_conditional( p )) )    /* ignore non control special */
  191.       {                        /* targets               */
  192.      res  = _handle_conditional( res, &token );
  193.      skip = TRUE;
  194.       }
  195.       else {
  196.      CLEAR_TOKEN( &token );
  197.      res  = TRUE;
  198.       }
  199.    }
  200.  
  201.    if( skip ) {
  202.       buf  = buf_org;        /* ignore line just read in */
  203.       pos  = 0;
  204.       skip = res;
  205.       goto do_again;
  206.    }
  207.  
  208.    DB_PRINT( "io", ("Returning [%s]", buf) );
  209.    DB_RETURN( FALSE );
  210. }
  211.  
  212.  
  213. PUBLIC char *
  214. Do_comment(str, pend, keep)/*
  215. =============================
  216.    Search the input string looking for comment chars.  If it contains
  217.    comment chars then NUKE the remainder of the line, if the comment
  218.    char is preceeded by \ then shift the remainder of the line left
  219.    by one char. */
  220. char *str;
  221. char **pend;
  222. int  keep;
  223. {
  224.    char *c = str;
  225.  
  226.    while( (c = strchr(c, COMMENT_CHAR)) != NIL(char) ) {
  227.       if( Comment || State == NORMAL_SCAN )
  228.      if( c != str && c[-1] == ESCAPE_CHAR ) {
  229.         strcpy( c-1, c );        /* copy it left, due to \# */
  230.         if( pend ) (*pend)--;    /* shift tail pointer left */
  231.      }
  232.      else {
  233.         if(    !No_exec
  234.         && c == str
  235.             && c[1] == '!'
  236.             && Line_number == 1
  237.         && Nestlevel() == 1 ) {
  238.            char *cmnd;
  239.          
  240.            cmnd = Expand(c+2);
  241.            cmnd[strlen(cmnd)-1] = '\0';    /* strip last newline */
  242.            Current_target = Root;
  243.            Swap_on_exec = TRUE;
  244.            Wait_for_completion = TRUE;
  245.            Do_cmnd(cmnd, FALSE, TRUE, Current_target, FALSE, FALSE, TRUE);
  246.         }
  247.  
  248.         *c = '\0';               /* a true comment so break */
  249.         break;
  250.      }
  251.       else {
  252.          if( keep )
  253.         c = NIL(char);
  254.      else
  255.         *c = '\0';
  256.  
  257.      break;
  258.       }
  259.    }
  260.  
  261.    return(c);
  262. }
  263.       
  264.  
  265. PUBLIC char *
  266. Get_token( string, brk, anchor )/*
  267. ==================================
  268.     Return the next token in string.
  269.     Returns empty string when no more tokens in string.
  270.     brk is a list of chars that also cause breaks in addition to space and
  271.     tab, but are themselves returned as tokens.  if brk is NULL then the
  272.     remainder of the line is returned as a single token.
  273.     
  274.     anchor if 1, says break on chars in the brk list, but only if
  275.     the entire token begins with the first char of the brk list, if
  276.     0 then any char of brk will cause a break to occurr.
  277.     
  278.     If anchor is 2, then break only seeing the first char in the break
  279.     list allowing only chars in the break list to form the prefix. */
  280.  
  281. TKSTRPTR  string;
  282. char      *brk;
  283. int      anchor;
  284. {
  285.    register char *s;
  286.    register char *curp;
  287.    register char *t;
  288.    int           done = FALSE;
  289.    char          space[10];
  290.  
  291.    DB_ENTER( "Get_token" );
  292.  
  293.    s  = string->tk_str;              /* Get string parameters    */
  294.    *s = string->tk_cchar;          /* ... and strip leading w/s    */
  295.  
  296.    SCAN_WHITE( s );
  297.  
  298.    DB_PRINT( "tok", ("What's left [%s]", s) );
  299.  
  300.    if( !*s ) {
  301.       DB_PRINT( "tok", ("Returning NULL token") );
  302.       DB_RETURN( "" );
  303.    }
  304.  
  305.  
  306.    /* Build the space list.  space contains all those chars that may possibly
  307.     * cause breaks.  This includes the brk list as well as white space. */
  308.  
  309.    if( brk != NIL(char) ) {
  310.       strcpy( space, " \t\r\n" );
  311.       strcat( space, brk   );
  312.    }
  313.    else {
  314.       space[0] = 0xff;            /* a char we know will not show up      */
  315.       space[1] = 0;
  316.    }
  317.  
  318.  
  319.    /* Handle processing of quoted tokens.  Note that this is disabled if
  320.     * brk is equal to NIL */
  321.  
  322.    while( *s == '\"' && ((brk != NIL(char)) || !string->tk_quote) ) {
  323.       s++;
  324.       if( string->tk_quote ) {
  325.      curp = s-1;
  326.      do { curp = strchr( curp+1, '\"' ); }
  327.      while( (curp != NIL(char)) && (*(curp+1) == '\"'));
  328.  
  329.          if( curp == NIL(char) ) Fatal( "Unmatched quote in token" );
  330.      string->tk_quote = !string->tk_quote;
  331.  
  332.      /* Check for "" case, and if found ignore it */
  333.      if( curp == s ) continue;
  334.      goto found_token;
  335.       }
  336.       else
  337.      SCAN_WHITE( s );
  338.  
  339.       string->tk_quote = !string->tk_quote;
  340.    }
  341.    
  342.  
  343.    /* Check for a token break character at the beginning of the token.
  344.     * If found return the next set of break chars as a token. */
  345.  
  346.    if( anchor == 2 && brk != NIL(char) ) {
  347.       curp = s;
  348.       while( *curp && (strchr(brk,*curp)!=NIL(char)) && (*curp!=*brk) ) curp++;
  349.       done = (*brk == *curp++);
  350.    }
  351.    else if( (brk != NIL(char)) && (strchr( brk, *s ) != NIL(char)) ) {
  352.       curp = _strspn( s, brk );
  353.       done = (anchor == 0) ? TRUE :
  354.          ((anchor == 1)?(*s == *brk) : (*brk == curp[-1]));
  355.    }
  356.  
  357.  
  358.    /* Scan for the next token in the list and return it less the break char
  359.     * that was used to terminate the token.  It will possibly be returned in
  360.     * the next call to Get_token */
  361.  
  362.    if( !done ) {
  363.       SCAN_WHITE( s );
  364.  
  365.       t = s;
  366.       do {
  367.      done = TRUE;
  368.      curp = _strpbrk(t, space);
  369.      
  370.      if( anchor && *curp && !IS_WHITE( *curp ) )
  371.         if( ((anchor == 1)?*curp:_strspn(curp,brk)[-1]) != *brk ) {
  372.            t++;
  373.            done = FALSE;
  374.         }
  375.       }
  376.       while( !done );
  377.  
  378.       if( (curp == s) && (strchr(brk, *curp) != NIL(char)) ) curp++;
  379.    }
  380.  
  381. found_token:
  382.    string->tk_str   = curp;
  383.    string->tk_cchar = *curp;
  384.    *curp = '\0';
  385.  
  386.    DB_PRINT( "tok", ("Returning [%s]", s) );
  387.    DB_RETURN( s );
  388. }
  389.  
  390.  
  391. static int
  392. _is_conditional( tg )/*
  393. =======================
  394.     Look at tg and return it's value if it is a conditional identifier
  395.     otherwise return 0. */
  396. char *tg;
  397. {
  398.    DB_ENTER( "_is_conditional" );
  399.    
  400.    tg++;
  401.    switch( *tg ) {
  402.       case 'I': if( !strcmp( tg, "IF" )) DB_RETURN( ST_IF   ); break;
  403.       
  404.       case 'E':
  405.          if( !strcmp( tg, "END" ))     DB_RETURN( ST_END  );
  406.          else if( !strcmp( tg, "ENDIF")) DB_RETURN( ST_END  );
  407.          else if( !strcmp( tg, "ELSE" )) DB_RETURN( ST_ELSE );
  408.          else if( !strcmp( tg, "ELIF" )) DB_RETURN( ST_ELIF );
  409.      break;
  410.    }
  411.    
  412.    DB_RETURN( 0 );
  413. }
  414.  
  415.  
  416.  
  417. #define SEEN_END  0x00
  418. #define SEEN_IF   0x01
  419. #define SEEN_ELSE 0x02
  420. #define SEEN_ELIF 0x04
  421.  
  422. #define ACCEPT_IF   0x10
  423. #define ACCEPT_ELIF 0x20
  424.  
  425. static int
  426. _handle_conditional( opcode, tg )/*
  427. ===================================
  428.     Perform the necessary processing for .IF conditinal targets.
  429.     Someday this should be modified to do bracketted expressions ala
  430.     CPP... sigh */
  431. int      opcode;
  432. TKSTRPTR tg;
  433. {
  434.    static short    action[MAX_COND_DEPTH];
  435.    static char  ifcntl[MAX_COND_DEPTH];
  436.    char     *tok, *lhs, *rhs, *op, *expr;
  437.    int      result;
  438.  
  439.    DB_ENTER( "_handle_conditional" );
  440.  
  441.    switch( opcode ) {
  442.       case ST_ELIF:
  443.          if( !(ifcntl[Nest_level] & SEEN_IF) || (ifcntl[Nest_level]&SEEN_ELSE) )
  444.         Fatal(".ELIF without a preceeding .IF" );
  445.      /* FALLTHROUGH */
  446.  
  447.       case ST_IF:
  448.      if( opcode == ST_IF && (Nest_level+1) == MAX_COND_DEPTH )
  449.         Fatal( ".IF .ELSE ... .END nesting too deep" );
  450.  
  451.      If_expand = TRUE;
  452.      expr = Expand( Get_token( tg, NIL(char), FALSE ));
  453.      If_expand = FALSE;
  454.      lhs = _strspn( expr, " \t" );
  455.      if( !*lhs ) lhs = NIL(char);
  456.  
  457.      if( (op = _strstr( lhs, "==" )) == NIL(char) )
  458.         op = _strstr( lhs, "!=" );
  459.  
  460.      if( op == NIL(char) )
  461.         result = (lhs != NIL(char));
  462.      else {
  463.         op[1] = op[0];
  464.         if( lhs != op ) {
  465.            for( tok = op-1; (tok != lhs) && ((*tok == ' ')||(*tok == '\t'));
  466.                 tok-- );
  467.            tok[1] = '\0';
  468.         }
  469.         else
  470.            lhs = NIL(char);
  471.  
  472.         op++;
  473.         rhs = _strspn( op+1, " \t" );
  474.         if( !*rhs ) rhs = NIL(char);
  475.  
  476.         if( (rhs == NIL(char)) || (lhs == NIL(char)) )
  477.            result = (rhs == lhs) ? TRUE : FALSE;
  478.         else {
  479.            tok = rhs + strlen( rhs );
  480.            for( tok=tok-1; (tok != lhs) && ((*tok == ' ')||(*tok == '\t'));
  481.             tok--);
  482.            tok[1] = '\0';
  483.  
  484.            result = (strcmp( lhs, rhs ) == 0) ? TRUE : FALSE;
  485.         }
  486.  
  487.         if( *op == '!' ) result = !result;
  488.      }
  489.  
  490.      if( expr != NIL(char) ) FREE( expr );
  491.  
  492.      if( opcode == ST_IF ) {
  493.         Nest_level++;
  494.         action[Nest_level] = 1;
  495.      }
  496.      ifcntl[Nest_level] |= (opcode==ST_IF)?SEEN_IF:SEEN_ELIF;
  497.  
  498.      if( result ) {
  499.         if( !(ifcntl[Nest_level] & (ACCEPT_IF|ACCEPT_ELIF)) ) {
  500.            action[ Nest_level ] = action[ Nest_level-1 ];
  501.            ifcntl[Nest_level] |= (opcode==ST_IF)?ACCEPT_IF:ACCEPT_ELIF;
  502.         }
  503.         else
  504.            action[Nest_level] = 1;
  505.      }
  506.      else
  507.         action[Nest_level] = 1;
  508.      break;
  509.  
  510.       case ST_ELSE:
  511.      if( Nest_level <= 0 ) Fatal( ".ELSE without .IF" );
  512.      if( ifcntl[Nest_level] & SEEN_ELSE )
  513.         Fatal( "Missing .IF or .ELIF before .ELSE" );
  514.  
  515.      if( ifcntl[Nest_level] & (ACCEPT_IF|ACCEPT_ELIF) )
  516.         action[Nest_level] = 1;
  517.      else if( action[ Nest_level-1 ] != 1 )
  518.         action[ Nest_level ] ^= 0x1;    /* flip between 0 and 1    */
  519.  
  520.      ifcntl[Nest_level] |= SEEN_ELSE;
  521.      break;
  522.  
  523.       case ST_END:
  524.      ifcntl[Nest_level] = SEEN_END;
  525.      Nest_level--;
  526.      if( Nest_level < 0 ) Fatal( "Unmatched .END[IF]" );
  527.      break;
  528.    }
  529.  
  530.    DB_RETURN( action[ Nest_level ] );
  531. }
  532.